'use strict';
const tableDefinitions = require('../../config/mysqlTable');

/**
 * MySQL表初始化工具
 * 用于检查和创建MySQL数据库表
 */
class MySQLTableInitializer {
  /**
   * 构造函数
   * @param {Object} mysqlService MySQL服务实例
   */
  constructor(mysqlService) {
    this.mysql = mysqlService;
  }

  /**
   * 初始化所有表
   * @returns {Promise<boolean>} 是否成功
   */
  async initializeAllTables() {
    if (!this.mysql) {
      console.error('[MySQLTableInitializer] MySQL服务不可用');
      return false;
    }

    try {
      // 检查连接状态
      const isConnected = await this.mysql.isConnected;
      if (!isConnected) {
        console.log('[MySQLTableInitializer] MySQL未连接，尝试连接...');
        const connected = await this.mysql.connect();
        if (!connected) {
          console.error('[MySQLTableInitializer] 无法连接到MySQL');
          return false;
        }
      }

      // 获取当前数据库中的所有表
      const existingTablesResult = await this.mysql.listTables();
      const existingTables = new Set();

      // 处理不同数据库返回的结果格式
      if (Array.isArray(existingTablesResult)) {
        // 如果结果直接是数组
        for (const row of existingTablesResult) {
          const tableName = Object.values(row)[0];
          existingTables.add(tableName);
        }
      }

      console.log(`[MySQLTableInitializer] 当前数据库中的表: ${Array.from(existingTables).join(', ')}`);

      // 初始化表定义中的每个表
      for (const [tableName, tableSchema] of Object.entries(tableDefinitions)) {
        if (!existingTables.has(tableName)) {
          console.log(`[MySQLTableInitializer] 创建表: ${tableName}`);
          await this.createTable(tableName, tableSchema);
        } else if (this.isDebug) {
          console.log(`[MySQLTableInitializer] 表已存在: ${tableName}`);
        }
      }

      console.log('[MySQLTableInitializer] 所有表初始化完成');
      return true;
    } catch (error) {
      console.error('[MySQLTableInitializer] 初始化表时出错:', error);
      return false;
    }
  }

  /**
   * 创建单个表
   * @param {string} tableName 表名
   * @param {Object} schema 表结构定义
   * @returns {Promise<boolean>} 是否成功
   */
  async createTable(tableName, schema) {
    try {
      // 提取索引定义
      const indexes = schema.INDEXES || [];
      const schemaWithoutIndexes = { ...schema };
      delete schemaWithoutIndexes.INDEXES;

      // 构建创建表的SQL
      let sql = `CREATE TABLE ${this.mysql.escapeId(tableName)} (\n`;

      // 添加字段定义
      const fields = Object.entries(schemaWithoutIndexes).map(([fieldName, definition]) => {
        return `  ${this.mysql.escapeId(fieldName)} ${definition}`;
      });

      // 添加索引定义
      if (indexes.length > 0) {
        fields.push(...indexes.map(index => `  ${index}`));
      }

      sql += fields.join(',\n');
      sql += '\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;';

      // 执行SQL
      if (this.isDebug) {
        console.debug(`[MySQLTableInitializer] 执行SQL:\n${sql}`);
      }

      await this.mysql.execute(sql);
      console.log(`[MySQLTableInitializer] 表 ${tableName} 创建成功`);
      return true;
    } catch (error) {
      console.error(`[MySQLTableInitializer] 创建表 ${tableName} 失败:`, error);
      return false;
    }
  }

  /**
   * 检查表是否存在
   * @param {string} tableName 表名
   * @returns {Promise<boolean>} 是否存在
   */
  async tableExists(tableName) {
    try {
      const result = await this.mysql.queryOne(
        'SELECT 1 FROM information_schema.tables WHERE table_schema = ? AND table_name = ? LIMIT 1',
        [await this.mysql.databaseName(), tableName]
      );
      return !!result;
    } catch (error) {
      console.error(`[MySQLTableInitializer] 检查表 ${tableName} 是否存在时出错:`, error);
      return false;
    }
  }

  /**
   * 删除表
   * @param {string} tableName 表名
   * @returns {Promise<boolean>} 是否成功
   */
  async dropTable(tableName) {
    try {
      await this.mysql.execute(`DROP TABLE IF EXISTS ${this.mysql.escapeId(tableName)}`);
      console.log(`[MySQLTableInitializer] 表 ${tableName} 删除成功`);
      return true;
    } catch (error) {
      console.error(`[MySQLTableInitializer] 删除表 ${tableName} 失败:`, error);
      return false;
    }
  }

  /**
   * 重置表（删除后重新创建）
   * @param {string} tableName 表名
   * @returns {Promise<boolean>} 是否成功
   */
  async resetTable(tableName) {
    try {
      const schema = tableDefinitions[tableName];
      if (!schema) {
        console.error(`[MySQLTableInitializer] 表 ${tableName} 没有定义`);
        return false;
      }

      await this.dropTable(tableName);
      await this.createTable(tableName, schema);
      return true;
    } catch (error) {
      console.error(`[MySQLTableInitializer] 重置表 ${tableName} 失败:`, error);
      return false;
    }
  }

  /**
   * 重置所有表
   * @returns {Promise<boolean>} 是否成功
   */
  async resetAllTables() {
    try {
      for (const tableName of Object.keys(tableDefinitions)) {
        await this.resetTable(tableName);
      }
      console.log('[MySQLTableInitializer] 所有表重置完成');
      return true;
    } catch (error) {
      console.error('[MySQLTableInitializer] 重置所有表时出错:', error);
      return false;
    }
  }
}

module.exports = MySQLTableInitializer; 